Modern C++ Tutorial: Beyond the NULL Trap

The transition from C-style macros to C++ type-safe literals represents a fundamental shift in language usability, resolving the "NULL Trap" where zero-macro ambiguity causes silent logical errors.

1. The Overload Resolution Failure

In legacy standards (C++98), NULL is often defined as 0. When passed to overloaded functions, the compiler resolves NULL as an integer. This is evidenced by:

if (std::is_same<decltype(NULL), decltype(0)>::value)
std::cout << "NULL is an int";

2. The nullptr Solution

C++11 introduced nullptr, a keyword of type std::nullptr_t. Unlike the macro, it cannot be implicitly converted to an integral type (except bool), ensuring pointer-specific overloads are selected.

3. Linkage & Interoperability

Modern C++ requires extern "C" to prevent name mangling when linking with C code (e.g., compiled with gcc). Maintaining type-safe pointers at this boundary is critical.

$$\text{std::nullptr\_t} \neq \text{int}$$

TERMINAL bash — 80x24

> Ready. Click "Run" to execute.

QUESTION 1

What is the primary reason C++11 introduced nullptr?

To speed up pointer arithmetic.

To resolve ambiguity in function overloading between pointers and integers.

To replace the delete keyword.

To allow pointers to store floating-point values.

✅ Correct!

Exactly. nullptr has its own type std::nullptr_t, preventing the compiler from confusing it with an integer 0.

❌ Incorrect

The issue is type ambiguity. NULL often expands to 0, which is an integer, not a pointer type.

QUESTION 2

In a modern C++ environment, what is the type of nullptr?

void*

int

std::nullptr_t

long long

✅ Correct!

std::nullptr_t is the distinct type of the nullptr literal.

❌ Incorrect

While nullptr converts to pointers, its actual type is std::nullptr_t.

QUESTION 3

Which keyword prevents C++ from mangling function names when linking with C code?

static

extern "C"

inline

virtual

✅ Correct!

extern "C" instructs the C++ compiler to use C linkage conventions.

❌ Incorrect

C++ mangles names to support overloading; extern "C" disables this for compatibility.

QUESTION 4

What happens if you check std::is_same<decltype(NULL), std::nullptr_t>::value in C++11?

It is always true.

It is usually false (NULL is often 0 or 0L).

It results in a compiler error.

It depends on the #include header.

❌ Incorrect

NULL remains an implementation-defined macro for backward compatibility; it is not synonymous with nullptr_t.

QUESTION 5

Which compiler version was used in the example to demonstrate target x86_64-apple-darwin?

GCC 9.1

Apple LLVM version 10.0.1 (clang-1001.0.46.4)

MSVC 2019

MinGW 64

✅ Correct!

Correct, as seen in the clang++ -v output snippet provided.